package org.aspectsense.utilitydsl;
//$ANTLR 3.2 Sep 23, 2009 12:02:23 UtilTree.g 2010-01-28 15:04:09

import org.antlr.runtime.*;
import org.antlr.runtime.tree.*;
import org.aspectsense.middleware.controller.ContextManager;
import org.aspectsense.middleware.controller.UtilityManager;




public class UtilTree extends TreeParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "PLUS", "MINUS", "MULT", "DIV", "LT", "LTE", "GT", "GTE", "EQ", "NEQ", "CONTEXT", "CONTEXT_ID", "UTILITY", "ID", "INT", "FLOAT", "EXPONENT", "WS", "'?'", "':'", "'('", "')'"
    };
    public static final int LT=8;
    public static final int EXPONENT=20;
    public static final int T__25=25;
    public static final int T__24=24;
    public static final int T__23=23;
    public static final int T__22=22;
    public static final int GTE=11;
    public static final int FLOAT=19;
    public static final int INT=18;
    public static final int MINUS=5;
    public static final int MULT=6;
    public static final int ID=17;
    public static final int EOF=-1;
    public static final int LTE=9;
    public static final int CONTEXT=14;
    public static final int NEQ=13;
    public static final int WS=21;
    public static final int UTILITY=16;
    public static final int CONTEXT_ID=15;
    public static final int GT=10;
    public static final int PLUS=4;
    public static final int EQ=12;
    public static final int DIV=7;

    // delegates
    // delegators


        public UtilTree(TreeNodeStream input) {
            this(input, new RecognizerSharedState());
        }
        public UtilTree(TreeNodeStream input, RecognizerSharedState state) {
            super(input, state);
             
        }
        

    public String[] getTokenNames() { return UtilTree.tokenNames; }
    public String getGrammarFileName() { return "UtilTree.g"; }



    // $ANTLR start "prog"
    // UtilTree.g:10:1: prog : ( stat )+ ;
    public final double prog() throws RecognitionException {
        double stat1 = 0.0;


        try {
            // UtilTree.g:10:11: ( ( stat )+ )
            // UtilTree.g:10:12: ( stat )+
            {
            // UtilTree.g:10:12: ( stat )+
            int cnt1=0;
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( ((LA1_0>=PLUS && LA1_0<=DIV)||LA1_0==CONTEXT||LA1_0==UTILITY||(LA1_0>=INT && LA1_0<=FLOAT)||LA1_0==22) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // UtilTree.g:10:13: stat
            	    {
            	    pushFollow(FOLLOW_stat_in_prog35);
            	    stat1=stat();

            	    state._fsp--;

            	    //System.out.println(stat1);

            	    }
            	    break;

            	default :
            	    if ( cnt1 >= 1 ) break loop1;
                        EarlyExitException eee =
                            new EarlyExitException(1, input);
                        throw eee;
                }
                cnt1++;
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return stat1;
    }
    // $ANTLR end "prog"


    // $ANTLR start "stat"
    // UtilTree.g:13:1: stat returns [double value] : ( ^( '?' ^( LT a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( LTE a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( GT a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( GTE a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( EQ a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( NEQ a= expr b= expr ) c= expr d= expr ) | expr );
    public final double stat() throws RecognitionException {
        double value = 0.0;

        double a = 0.0;

        double b = 0.0;

        double c = 0.0;

        double d = 0.0;

        double expr2 = 0.0;


        try {
            // UtilTree.g:13:32: ( ^( '?' ^( LT a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( LTE a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( GT a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( GTE a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( EQ a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( NEQ a= expr b= expr ) c= expr d= expr ) | expr )
            int alt2=7;
            alt2 = dfa2.predict(input);
            switch (alt2) {
                case 1 :
                    // UtilTree.g:13:34: ^( '?' ^( LT a= expr b= expr ) c= expr d= expr )
                    {
                    match(input,22,FOLLOW_22_in_stat61); 

                    match(input, Token.DOWN, null); 
                    match(input,LT,FOLLOW_LT_in_stat64); 

                    match(input, Token.DOWN, null); 
                    pushFollow(FOLLOW_expr_in_stat68);
                    a=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_stat72);
                    b=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    pushFollow(FOLLOW_expr_in_stat77);
                    c=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_stat81);
                    d=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    if (a<b) {value =c;} else {value =d;}

                    }
                    break;
                case 2 :
                    // UtilTree.g:14:9: ^( '?' ^( LTE a= expr b= expr ) c= expr d= expr )
                    {
                    match(input,22,FOLLOW_22_in_stat96); 

                    match(input, Token.DOWN, null); 
                    match(input,LTE,FOLLOW_LTE_in_stat99); 

                    match(input, Token.DOWN, null); 
                    pushFollow(FOLLOW_expr_in_stat103);
                    a=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_stat107);
                    b=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    pushFollow(FOLLOW_expr_in_stat112);
                    c=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_stat116);
                    d=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    if (a<=b) {value =c;} else {value =d;}

                    }
                    break;
                case 3 :
                    // UtilTree.g:15:9: ^( '?' ^( GT a= expr b= expr ) c= expr d= expr )
                    {
                    match(input,22,FOLLOW_22_in_stat132); 

                    match(input, Token.DOWN, null); 
                    match(input,GT,FOLLOW_GT_in_stat135); 

                    match(input, Token.DOWN, null); 
                    pushFollow(FOLLOW_expr_in_stat139);
                    a=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_stat143);
                    b=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    pushFollow(FOLLOW_expr_in_stat148);
                    c=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_stat152);
                    d=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    if (a>b) {value =c;} else {value =d;}

                    }
                    break;
                case 4 :
                    // UtilTree.g:16:9: ^( '?' ^( GTE a= expr b= expr ) c= expr d= expr )
                    {
                    match(input,22,FOLLOW_22_in_stat167); 

                    match(input, Token.DOWN, null); 
                    match(input,GTE,FOLLOW_GTE_in_stat170); 

                    match(input, Token.DOWN, null); 
                    pushFollow(FOLLOW_expr_in_stat174);
                    a=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_stat178);
                    b=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    pushFollow(FOLLOW_expr_in_stat183);
                    c=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_stat187);
                    d=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    if (a>=b) {value =c;} else {value =d;}

                    }
                    break;
                case 5 :
                    // UtilTree.g:17:9: ^( '?' ^( EQ a= expr b= expr ) c= expr d= expr )
                    {
                    match(input,22,FOLLOW_22_in_stat203); 

                    match(input, Token.DOWN, null); 
                    match(input,EQ,FOLLOW_EQ_in_stat206); 

                    match(input, Token.DOWN, null); 
                    pushFollow(FOLLOW_expr_in_stat210);
                    a=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_stat214);
                    b=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    pushFollow(FOLLOW_expr_in_stat219);
                    c=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_stat223);
                    d=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    if (a==b) {value =c;} else {value =d;}

                    }
                    break;
                case 6 :
                    // UtilTree.g:18:9: ^( '?' ^( NEQ a= expr b= expr ) c= expr d= expr )
                    {
                    match(input,22,FOLLOW_22_in_stat239); 

                    match(input, Token.DOWN, null); 
                    match(input,NEQ,FOLLOW_NEQ_in_stat242); 

                    match(input, Token.DOWN, null); 
                    pushFollow(FOLLOW_expr_in_stat246);
                    a=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_stat250);
                    b=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    pushFollow(FOLLOW_expr_in_stat255);
                    c=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_stat259);
                    d=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    if (a!=b) {value =c;} else {value =d;}

                    }
                    break;
                case 7 :
                    // UtilTree.g:19:9: expr
                    {
                    pushFollow(FOLLOW_expr_in_stat272);
                    expr2=expr();

                    state._fsp--;

                    value =expr2;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return value;
    }
    // $ANTLR end "stat"


    // $ANTLR start "func"
    // UtilTree.g:23:1: func returns [double value] : ( ^( CONTEXT CONTEXT_ID ) | ^( UTILITY ID ) );
    public final double func() throws RecognitionException {
        double value = 0.0;

        CommonTree CONTEXT_ID3=null;
        CommonTree ID4=null;

        try {
            // UtilTree.g:23:31: ( ^( CONTEXT CONTEXT_ID ) | ^( UTILITY ID ) )
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0==CONTEXT) ) {
                alt3=1;
            }
            else if ( (LA3_0==UTILITY) ) {
                alt3=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }
            switch (alt3) {
                case 1 :
                    // UtilTree.g:23:33: ^( CONTEXT CONTEXT_ID )
                    {
                    match(input,CONTEXT,FOLLOW_CONTEXT_in_func312); 

                    match(input, Token.DOWN, null); 
                    CONTEXT_ID3=(CommonTree)match(input,CONTEXT_ID,FOLLOW_CONTEXT_ID_in_func314); 

                    match(input, Token.UP, null); 
 //Here we call ContexManager
                  
                    value =ContextManager.getValue((CONTEXT_ID3!=null?CONTEXT_ID3.getText():null));

                    }
                    break;
                case 2 :
                    // UtilTree.g:24:9: ^( UTILITY ID )
                    {
                    match(input,UTILITY,FOLLOW_UTILITY_in_func328); 

                    match(input, Token.DOWN, null); 
                    ID4=(CommonTree)match(input,ID,FOLLOW_ID_in_func330); 

                    match(input, Token.UP, null); 
 //Here we call UtilityManager                   
                    
                    value =UtilityManager.getValue((ID4!=null?ID4.getText():null));

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return value;
    }
    // $ANTLR end "func"


    // $ANTLR start "expr"
    // UtilTree.g:27:1: expr returns [double value] : ( ^( '+' a= expr b= expr ) | ^( '-' a= expr b= expr ) | ^( '*' a= expr b= expr ) | ^( '/' a= expr b= expr ) | FLOAT | INT | func );
    public final double expr() throws RecognitionException {
        double value = 0.0;

        CommonTree FLOAT5=null;
        CommonTree INT6=null;
        double a = 0.0;

        double b = 0.0;

        double func7 = 0.0;


        try {
            // UtilTree.g:27:31: ( ^( '+' a= expr b= expr ) | ^( '-' a= expr b= expr ) | ^( '*' a= expr b= expr ) | ^( '/' a= expr b= expr ) | FLOAT | INT | func )
            int alt4=7;
            switch ( input.LA(1) ) {
            case PLUS:
                {
                alt4=1;
                }
                break;
            case MINUS:
                {
                alt4=2;
                }
                break;
            case MULT:
                {
                alt4=3;
                }
                break;
            case DIV:
                {
                alt4=4;
                }
                break;
            case FLOAT:
                {
                alt4=5;
                }
                break;
            case INT:
                {
                alt4=6;
                }
                break;
            case CONTEXT:
            case UTILITY:
                {
                alt4=7;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;
            }

            switch (alt4) {
                case 1 :
                    // UtilTree.g:27:33: ^( '+' a= expr b= expr )
                    {
                    match(input,PLUS,FOLLOW_PLUS_in_expr355); 

                    match(input, Token.DOWN, null); 
                    pushFollow(FOLLOW_expr_in_expr359);
                    a=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_expr363);
                    b=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    value =a+b;

                    }
                    break;
                case 2 :
                    // UtilTree.g:28:9: ^( '-' a= expr b= expr )
                    {
                    match(input,MINUS,FOLLOW_MINUS_in_expr377); 

                    match(input, Token.DOWN, null); 
                    pushFollow(FOLLOW_expr_in_expr381);
                    a=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_expr385);
                    b=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    value =a-b;

                    }
                    break;
                case 3 :
                    // UtilTree.g:29:9: ^( '*' a= expr b= expr )
                    {
                    match(input,MULT,FOLLOW_MULT_in_expr399); 

                    match(input, Token.DOWN, null); 
                    pushFollow(FOLLOW_expr_in_expr403);
                    a=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_expr407);
                    b=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    value =a*b;

                    }
                    break;
                case 4 :
                    // UtilTree.g:30:13: ^( '/' a= expr b= expr )
                    {
                    match(input,DIV,FOLLOW_DIV_in_expr425); 

                    match(input, Token.DOWN, null); 
                    pushFollow(FOLLOW_expr_in_expr429);
                    a=expr();

                    state._fsp--;

                    pushFollow(FOLLOW_expr_in_expr433);
                    b=expr();

                    state._fsp--;


                    match(input, Token.UP, null); 
                    value =a/b;

                    }
                    break;
                case 5 :
                    // UtilTree.g:31:9: FLOAT
                    {
                    FLOAT5=(CommonTree)match(input,FLOAT,FOLLOW_FLOAT_in_expr446); 
                    value = Double.parseDouble((FLOAT5!=null?FLOAT5.getText():null));

                    }
                    break;
                case 6 :
                    // UtilTree.g:32:13: INT
                    {
                    INT6=(CommonTree)match(input,INT,FOLLOW_INT_in_expr462); 
                    value = Integer.parseInt((INT6!=null?INT6.getText():null));

                    }
                    break;
                case 7 :
                    // UtilTree.g:33:13: func
                    {
                    pushFollow(FOLLOW_func_in_expr480);
                    func7=func();

                    state._fsp--;

                    value = func7;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return value;
    }
    // $ANTLR end "expr"

    // Delegated rules


    protected DFA2 dfa2 = new DFA2(this);
    static final String DFA2_eotS =
        "\12\uffff";
    static final String DFA2_eofS =
        "\12\uffff";
    static final String DFA2_minS =
        "\1\4\1\2\1\uffff\1\10\6\uffff";
    static final String DFA2_maxS =
        "\1\26\1\2\1\uffff\1\15\6\uffff";
    static final String DFA2_acceptS =
        "\2\uffff\1\7\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6";
    static final String DFA2_specialS =
        "\12\uffff}>";
    static final String[] DFA2_transitionS = {
            "\4\2\6\uffff\1\2\1\uffff\1\2\1\uffff\2\2\2\uffff\1\1",
            "\1\3",
            "",
            "\1\4\1\5\1\6\1\7\1\10\1\11",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS);
    static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS);
    static final char[] DFA2_min = DFA.unpackEncodedStringToUnsignedChars(DFA2_minS);
    static final char[] DFA2_max = DFA.unpackEncodedStringToUnsignedChars(DFA2_maxS);
    static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS);
    static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS);
    static final short[][] DFA2_transition;

    static {
        int numStates = DFA2_transitionS.length;
        DFA2_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA2_transition[i] = DFA.unpackEncodedString(DFA2_transitionS[i]);
        }
    }

    class DFA2 extends DFA {

        public DFA2(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 2;
            this.eot = DFA2_eot;
            this.eof = DFA2_eof;
            this.min = DFA2_min;
            this.max = DFA2_max;
            this.accept = DFA2_accept;
            this.special = DFA2_special;
            this.transition = DFA2_transition;
        }
        public String getDescription() {
            return "13:1: stat returns [double value] : ( ^( '?' ^( LT a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( LTE a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( GT a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( GTE a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( EQ a= expr b= expr ) c= expr d= expr ) | ^( '?' ^( NEQ a= expr b= expr ) c= expr d= expr ) | expr );";
        }
    }
 

    public static final BitSet FOLLOW_stat_in_prog35 = new BitSet(new long[]{0x00000000004D40F2L});
    public static final BitSet FOLLOW_22_in_stat61 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_LT_in_stat64 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expr_in_stat68 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_stat72 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_expr_in_stat77 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_stat81 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_22_in_stat96 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_LTE_in_stat99 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expr_in_stat103 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_stat107 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_expr_in_stat112 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_stat116 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_22_in_stat132 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_GT_in_stat135 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expr_in_stat139 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_stat143 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_expr_in_stat148 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_stat152 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_22_in_stat167 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_GTE_in_stat170 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expr_in_stat174 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_stat178 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_expr_in_stat183 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_stat187 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_22_in_stat203 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_EQ_in_stat206 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expr_in_stat210 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_stat214 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_expr_in_stat219 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_stat223 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_22_in_stat239 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_NEQ_in_stat242 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expr_in_stat246 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_stat250 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_expr_in_stat255 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_stat259 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_expr_in_stat272 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CONTEXT_in_func312 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_CONTEXT_ID_in_func314 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_UTILITY_in_func328 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_ID_in_func330 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_PLUS_in_expr355 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expr_in_expr359 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_expr363 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_MINUS_in_expr377 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expr_in_expr381 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_expr385 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_MULT_in_expr399 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expr_in_expr403 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_expr407 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_DIV_in_expr425 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expr_in_expr429 = new BitSet(new long[]{0x00000000004D40F8L});
    public static final BitSet FOLLOW_expr_in_expr433 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_FLOAT_in_expr446 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INT_in_expr462 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_func_in_expr480 = new BitSet(new long[]{0x0000000000000002L});

}